
package org.xteam.pascal.parser.ast;

public class PascalAstPackage {

	public static final PascalAstPackage INSTANCE = new PascalAstPackage();
	
	private org.xteam.parser.runtime.reflect.AstNodeType ProgramType;
	private org.xteam.parser.runtime.reflect.AstNodeType BlockType;
	private org.xteam.parser.runtime.reflect.AstNodeType ConstantDefinitionType;
	private org.xteam.parser.runtime.reflect.AstNodeType TypeDefinitionType;
	private org.xteam.parser.runtime.reflect.AstNodeType VariableDeclarationType;
	private org.xteam.parser.runtime.reflect.AstNodeType FunctionDefinitionType;
	private org.xteam.parser.runtime.reflect.AstNodeType ProcedureType;
	private org.xteam.parser.runtime.reflect.AstNodeType FunctionType;
	private org.xteam.parser.runtime.reflect.AstNodeType ParameterType;
	private org.xteam.parser.runtime.reflect.AstNodeType VariableParameterType;
	private org.xteam.parser.runtime.reflect.AstNodeType ProcedureParameterType;
	private org.xteam.parser.runtime.reflect.AstNodeType FunctionParameterType;
	private org.xteam.parser.runtime.reflect.AstNodeType VarFlagType;
	private org.xteam.parser.runtime.reflect.AstNodeType TypeType;
	private org.xteam.parser.runtime.reflect.AstNodeType ReferenceTypeType;
	private org.xteam.parser.runtime.reflect.AstNodeType ArraySchemaTypeType;
	private org.xteam.parser.runtime.reflect.AstNodeType PackedArraySchemaTypeType;
	private org.xteam.parser.runtime.reflect.AstNodeType RangeType;
	private org.xteam.parser.runtime.reflect.AstNodeType TypeReferenceType;
	private org.xteam.parser.runtime.reflect.AstNodeType EnumTypeType;
	private org.xteam.parser.runtime.reflect.AstNodeType RangeTypeType;
	private org.xteam.parser.runtime.reflect.AstNodeType PointerTypeType;
	private org.xteam.parser.runtime.reflect.AstNodeType ArrayTypeType;
	private org.xteam.parser.runtime.reflect.AstNodeType RecordTypeType;
	private org.xteam.parser.runtime.reflect.AstNodeType FieldsAndVariantType;
	private org.xteam.parser.runtime.reflect.AstNodeType RecordCaseType;
	private org.xteam.parser.runtime.reflect.AstNodeType VariantSelectorType;
	private org.xteam.parser.runtime.reflect.AstNodeType RecordCaseArmType;
	private org.xteam.parser.runtime.reflect.AstNodeType FieldType;
	private org.xteam.parser.runtime.reflect.AstNodeType SetTypeType;
	private org.xteam.parser.runtime.reflect.AstNodeType FileTypeType;
	private org.xteam.parser.runtime.reflect.AstNodeType PackedFlagType;
	private org.xteam.parser.runtime.reflect.AstNodeType StatementType;
	private org.xteam.parser.runtime.reflect.AstNodeType EmptyStatementType;
	private org.xteam.parser.runtime.reflect.AstNodeType LabelStatementType;
	private org.xteam.parser.runtime.reflect.AstNodeType AssignmentType;
	private org.xteam.parser.runtime.reflect.AstNodeType FunctionCallType;
	private org.xteam.parser.runtime.reflect.AstNodeType GotoType;
	private org.xteam.parser.runtime.reflect.AstNodeType CompoundType;
	private org.xteam.parser.runtime.reflect.AstNodeType IfType;
	private org.xteam.parser.runtime.reflect.AstNodeType CaseType;
	private org.xteam.parser.runtime.reflect.AstNodeType CaseArmType;
	private org.xteam.parser.runtime.reflect.AstNodeType RepeatUntilType;
	private org.xteam.parser.runtime.reflect.AstNodeType WhileType;
	private org.xteam.parser.runtime.reflect.AstNodeType ForType;
	private org.xteam.parser.runtime.reflect.AstNodeType WithType;
	private org.xteam.parser.runtime.reflect.AstNodeType DirectionFlagType;
	private org.xteam.parser.runtime.reflect.AstNodeType UpFlagType;
	private org.xteam.parser.runtime.reflect.AstNodeType DownFlagType;
	private org.xteam.parser.runtime.reflect.AstNodeType ExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType AccessType;
	private org.xteam.parser.runtime.reflect.AstNodeType VariableAccessType;
	private org.xteam.parser.runtime.reflect.AstNodeType ArrayAccessType;
	private org.xteam.parser.runtime.reflect.AstNodeType FieldAccessType;
	private org.xteam.parser.runtime.reflect.AstNodeType PointerAccessType;
	private org.xteam.parser.runtime.reflect.AstNodeType BinaryExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType EqualsExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType NotEqualsExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType LowerThanExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType GreaterThanExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType LowerOrEqualsExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType GreaterOrEqualsExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType InExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType AddExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType SubExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType OrExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType MulExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType DivExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType IntegralDivExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType ModuloExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType AndExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType NegateExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType NotExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType FormatExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType IdentifierExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType StringExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType NumberExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType IntegerExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType NilExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType FuncallExpressionType;
	private org.xteam.parser.runtime.reflect.AstNodeType IdentifierType;
	private org.xteam.parser.runtime.reflect.AstNodeType IntegerValueType;
	

	private PascalAstPackage() {
		init();
	}
	
	private void init() {
		ProgramType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("Program");
		BlockType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("Block");
		ConstantDefinitionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("ConstantDefinition");
		TypeDefinitionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("TypeDefinition");
		VariableDeclarationType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("VariableDeclaration");
		FunctionDefinitionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("FunctionDefinition");
		ProcedureType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("Procedure");
		FunctionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("Function");
		ParameterType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("Parameter");
		VariableParameterType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("VariableParameter");
		ProcedureParameterType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("ProcedureParameter");
		FunctionParameterType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("FunctionParameter");
		VarFlagType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("VarFlag");
		TypeType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("Type");
		ReferenceTypeType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("ReferenceType");
		ArraySchemaTypeType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("ArraySchemaType");
		PackedArraySchemaTypeType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("PackedArraySchemaType");
		RangeType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("Range");
		TypeReferenceType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("TypeReference");
		EnumTypeType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("EnumType");
		RangeTypeType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("RangeType");
		PointerTypeType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("PointerType");
		ArrayTypeType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("ArrayType");
		RecordTypeType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("RecordType");
		FieldsAndVariantType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("FieldsAndVariant");
		RecordCaseType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("RecordCase");
		VariantSelectorType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("VariantSelector");
		RecordCaseArmType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("RecordCaseArm");
		FieldType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("Field");
		SetTypeType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("SetType");
		FileTypeType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("FileType");
		PackedFlagType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("PackedFlag");
		StatementType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("Statement");
		EmptyStatementType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("EmptyStatement");
		LabelStatementType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("LabelStatement");
		AssignmentType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("Assignment");
		FunctionCallType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("FunctionCall");
		GotoType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("Goto");
		CompoundType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("Compound");
		IfType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("If");
		CaseType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("Case");
		CaseArmType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("CaseArm");
		RepeatUntilType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("RepeatUntil");
		WhileType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("While");
		ForType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("For");
		WithType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("With");
		DirectionFlagType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("DirectionFlag");
		UpFlagType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("UpFlag");
		DownFlagType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("DownFlag");
		ExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("Expression");
		AccessType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("Access");
		VariableAccessType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("VariableAccess");
		ArrayAccessType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("ArrayAccess");
		FieldAccessType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("FieldAccess");
		PointerAccessType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("PointerAccess");
		BinaryExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("BinaryExpression");
		EqualsExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("EqualsExpression");
		NotEqualsExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("NotEqualsExpression");
		LowerThanExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("LowerThanExpression");
		GreaterThanExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("GreaterThanExpression");
		LowerOrEqualsExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("LowerOrEqualsExpression");
		GreaterOrEqualsExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("GreaterOrEqualsExpression");
		InExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("InExpression");
		AddExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("AddExpression");
		SubExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("SubExpression");
		OrExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("OrExpression");
		MulExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("MulExpression");
		DivExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("DivExpression");
		IntegralDivExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("IntegralDivExpression");
		ModuloExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("ModuloExpression");
		AndExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("AndExpression");
		NegateExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("NegateExpression");
		NotExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("NotExpression");
		FormatExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("FormatExpression");
		IdentifierExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("IdentifierExpression");
		StringExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("StringExpression");
		NumberExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("NumberExpression");
		IntegerExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("IntegerExpression");
		NilExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("NilExpression");
		FuncallExpressionType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("FuncallExpression");
		IdentifierType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("Identifier");
		IntegerValueType = org.xteam.parser.runtime.reflect.AstTypeRegistry.INSTANCE.createNodeType("IntegerValue");
		ProgramType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("name", IdentifierType)		,
				new org.xteam.parser.runtime.reflect.AstListFeature("arguments", IdentifierType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("body", BlockType)		
		});
		BlockType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstListFeature("labels", IntegerValueType)		,
				new org.xteam.parser.runtime.reflect.AstListFeature("constants", ConstantDefinitionType)		,
				new org.xteam.parser.runtime.reflect.AstListFeature("types", TypeDefinitionType)		,
				new org.xteam.parser.runtime.reflect.AstListFeature("variables", VariableDeclarationType)		,
				new org.xteam.parser.runtime.reflect.AstListFeature("functions", FunctionDefinitionType)		,
				new org.xteam.parser.runtime.reflect.AstListFeature("statements", StatementType)		
		});
		ConstantDefinitionType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("name", IdentifierType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("value", ExpressionType)		
		});
		TypeDefinitionType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("name", IdentifierType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("value", TypeType)		
		});
		VariableDeclarationType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstListFeature("names", IdentifierType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("type", TypeType)		
		});
		FunctionDefinitionType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		ProcedureType.init(
			FunctionDefinitionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("name", IdentifierType)		,
				new org.xteam.parser.runtime.reflect.AstListFeature("parameters", ParameterType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("body", BlockType)		
		});
		FunctionType.init(
			FunctionDefinitionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("name", IdentifierType)		,
				new org.xteam.parser.runtime.reflect.AstListFeature("parameters", ParameterType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("returnType", IdentifierType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("body", BlockType)		
		});
		ParameterType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		VariableParameterType.init(
			ParameterType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("flag", VarFlagType)		,
				new org.xteam.parser.runtime.reflect.AstListFeature("names", IdentifierType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("type", TypeType)		
		});
		ProcedureParameterType.init(
			ParameterType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("name", IdentifierType)		,
				new org.xteam.parser.runtime.reflect.AstListFeature("parameters", ParameterType)		
		});
		FunctionParameterType.init(
			ParameterType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("name", IdentifierType)		,
				new org.xteam.parser.runtime.reflect.AstListFeature("parameters", ParameterType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("returnType", IdentifierType)		
		});
		VarFlagType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		TypeType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		ReferenceTypeType.init(
			TypeType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("name", IdentifierType)		
		});
		ArraySchemaTypeType.init(
			TypeType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstListFeature("ranges", RangeType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("type", TypeType)		
		});
		PackedArraySchemaTypeType.init(
			TypeType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("range", RangeType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("type", IdentifierType)		
		});
		RangeType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("from", IdentifierType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("to", IdentifierType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("step", IdentifierType)		
		});
		TypeReferenceType.init(
			TypeType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("name", IdentifierType)		
		});
		EnumTypeType.init(
			TypeType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstListFeature("names", IdentifierType)		
		});
		RangeTypeType.init(
			TypeType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("from", ExpressionType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("to", ExpressionType)		
		});
		PointerTypeType.init(
			TypeType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("type", IdentifierType)		
		});
		ArrayTypeType.init(
			TypeType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("flag", PackedFlagType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("type", TypeType)		,
				new org.xteam.parser.runtime.reflect.AstListFeature("indexes", TypeType)		
		});
		RecordTypeType.init(
			TypeType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("flag", PackedFlagType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("body", FieldsAndVariantType)		
		});
		FieldsAndVariantType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstListFeature("fields", FieldType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("variant", RecordCaseType)		
		});
		RecordCaseType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("selector", VariantSelectorType)		,
				new org.xteam.parser.runtime.reflect.AstListFeature("arms", RecordCaseArmType)		
		});
		VariantSelectorType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("name", IdentifierType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("type", IdentifierType)		
		});
		RecordCaseArmType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstListFeature("values", ExpressionType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("body", FieldsAndVariantType)		
		});
		FieldType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstListFeature("names", IdentifierType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("type", TypeType)		
		});
		SetTypeType.init(
			TypeType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("flag", PackedFlagType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("type", TypeType)		
		});
		FileTypeType.init(
			TypeType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("flag", PackedFlagType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("type", TypeType)		
		});
		PackedFlagType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		StatementType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		EmptyStatementType.init(
			StatementType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		LabelStatementType.init(
			StatementType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("label", IntegerValueType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("statement", StatementType)		
		});
		AssignmentType.init(
			StatementType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("variable", AccessType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("expression", ExpressionType)		
		});
		FunctionCallType.init(
			StatementType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("name", IdentifierType)		,
				new org.xteam.parser.runtime.reflect.AstListFeature("parameters", ExpressionType)		
		});
		GotoType.init(
			StatementType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("label", IntegerValueType)		
		});
		CompoundType.init(
			StatementType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstListFeature("statements", StatementType)		
		});
		IfType.init(
			StatementType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("condition", ExpressionType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("thenStatement", StatementType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("elseStatement", StatementType)		
		});
		CaseType.init(
			StatementType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("condition", ExpressionType)		,
				new org.xteam.parser.runtime.reflect.AstListFeature("arms", CaseArmType)		
		});
		CaseArmType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstListFeature("constants", ExpressionType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("statement", StatementType)		
		});
		RepeatUntilType.init(
			StatementType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("condition", ExpressionType)		,
				new org.xteam.parser.runtime.reflect.AstListFeature("statements", StatementType)		
		});
		WhileType.init(
			StatementType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("condition", ExpressionType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("statement", StatementType)		
		});
		ForType.init(
			StatementType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("variable", IdentifierType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("from", ExpressionType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("to", ExpressionType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("dir", DirectionFlagType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("statement", StatementType)		
		});
		WithType.init(
			StatementType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstListFeature("variables", AccessType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("statement", StatementType)		
		});
		DirectionFlagType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		UpFlagType.init(
			DirectionFlagType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		DownFlagType.init(
			DirectionFlagType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		ExpressionType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		AccessType.init(
			ExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		VariableAccessType.init(
			AccessType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("name", IdentifierType)		
		});
		ArrayAccessType.init(
			AccessType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("expression", AccessType)		,
				new org.xteam.parser.runtime.reflect.AstListFeature("indexes", ExpressionType)		
		});
		FieldAccessType.init(
			AccessType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("expression", AccessType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("name", IdentifierType)		
		});
		PointerAccessType.init(
			AccessType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("expression", AccessType)		
		});
		BinaryExpressionType.init(
			ExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("left", ExpressionType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("right", ExpressionType)		
		});
		EqualsExpressionType.init(
			BinaryExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		NotEqualsExpressionType.init(
			BinaryExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		LowerThanExpressionType.init(
			BinaryExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		GreaterThanExpressionType.init(
			BinaryExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		LowerOrEqualsExpressionType.init(
			BinaryExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		GreaterOrEqualsExpressionType.init(
			BinaryExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		InExpressionType.init(
			BinaryExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		AddExpressionType.init(
			BinaryExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		SubExpressionType.init(
			BinaryExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		OrExpressionType.init(
			BinaryExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		MulExpressionType.init(
			BinaryExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		DivExpressionType.init(
			BinaryExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		IntegralDivExpressionType.init(
			BinaryExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		ModuloExpressionType.init(
			BinaryExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		AndExpressionType.init(
			BinaryExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		NegateExpressionType.init(
			ExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("expression", ExpressionType)		
		});
		NotExpressionType.init(
			ExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("expression", ExpressionType)		
		});
		FormatExpressionType.init(
			ExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("expr", ExpressionType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("width", ExpressionType)		,
				new org.xteam.parser.runtime.reflect.AstNodeFeature("to", ExpressionType)		
		});
		IdentifierExpressionType.init(
			ExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		
			new org.xteam.parser.runtime.reflect.AstAttributeFeature("value", String.class)
		});
		StringExpressionType.init(
			ExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		
			new org.xteam.parser.runtime.reflect.AstAttributeFeature("value", String.class)
		});
		NumberExpressionType.init(
			ExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		
			new org.xteam.parser.runtime.reflect.AstAttributeFeature("value", String.class)
		});
		IntegerExpressionType.init(
			ExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		
			new org.xteam.parser.runtime.reflect.AstAttributeFeature("value", String.class)
		});
		NilExpressionType.init(
			ExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		});
		FuncallExpressionType.init(
			ExpressionType,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
				new org.xteam.parser.runtime.reflect.AstNodeFeature("name", IdentifierType)		,
				new org.xteam.parser.runtime.reflect.AstListFeature("arguments", ExpressionType)		
		});
		IdentifierType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		
			new org.xteam.parser.runtime.reflect.AstAttributeFeature("name", String.class)
		});
		IntegerValueType.init(
			null,
			new org.xteam.parser.runtime.reflect.AstFeature[] {
		
			new org.xteam.parser.runtime.reflect.AstAttributeFeature("value", String.class)
		});
	}
	
	public org.xteam.parser.runtime.reflect.AstNodeType getProgramType() {
		return ProgramType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getBlockType() {
		return BlockType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getConstantDefinitionType() {
		return ConstantDefinitionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getTypeDefinitionType() {
		return TypeDefinitionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getVariableDeclarationType() {
		return VariableDeclarationType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getFunctionDefinitionType() {
		return FunctionDefinitionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getProcedureType() {
		return ProcedureType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getFunctionType() {
		return FunctionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getParameterType() {
		return ParameterType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getVariableParameterType() {
		return VariableParameterType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getProcedureParameterType() {
		return ProcedureParameterType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getFunctionParameterType() {
		return FunctionParameterType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getVarFlagType() {
		return VarFlagType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getTypeType() {
		return TypeType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getReferenceTypeType() {
		return ReferenceTypeType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getArraySchemaTypeType() {
		return ArraySchemaTypeType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getPackedArraySchemaTypeType() {
		return PackedArraySchemaTypeType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getRangeType() {
		return RangeType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getTypeReferenceType() {
		return TypeReferenceType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getEnumTypeType() {
		return EnumTypeType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getRangeTypeType() {
		return RangeTypeType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getPointerTypeType() {
		return PointerTypeType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getArrayTypeType() {
		return ArrayTypeType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getRecordTypeType() {
		return RecordTypeType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getFieldsAndVariantType() {
		return FieldsAndVariantType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getRecordCaseType() {
		return RecordCaseType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getVariantSelectorType() {
		return VariantSelectorType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getRecordCaseArmType() {
		return RecordCaseArmType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getFieldType() {
		return FieldType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getSetTypeType() {
		return SetTypeType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getFileTypeType() {
		return FileTypeType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getPackedFlagType() {
		return PackedFlagType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getStatementType() {
		return StatementType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getEmptyStatementType() {
		return EmptyStatementType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getLabelStatementType() {
		return LabelStatementType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getAssignmentType() {
		return AssignmentType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getFunctionCallType() {
		return FunctionCallType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getGotoType() {
		return GotoType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getCompoundType() {
		return CompoundType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getIfType() {
		return IfType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getCaseType() {
		return CaseType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getCaseArmType() {
		return CaseArmType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getRepeatUntilType() {
		return RepeatUntilType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getWhileType() {
		return WhileType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getForType() {
		return ForType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getWithType() {
		return WithType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getDirectionFlagType() {
		return DirectionFlagType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getUpFlagType() {
		return UpFlagType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getDownFlagType() {
		return DownFlagType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getExpressionType() {
		return ExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getAccessType() {
		return AccessType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getVariableAccessType() {
		return VariableAccessType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getArrayAccessType() {
		return ArrayAccessType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getFieldAccessType() {
		return FieldAccessType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getPointerAccessType() {
		return PointerAccessType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getBinaryExpressionType() {
		return BinaryExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getEqualsExpressionType() {
		return EqualsExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getNotEqualsExpressionType() {
		return NotEqualsExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getLowerThanExpressionType() {
		return LowerThanExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getGreaterThanExpressionType() {
		return GreaterThanExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getLowerOrEqualsExpressionType() {
		return LowerOrEqualsExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getGreaterOrEqualsExpressionType() {
		return GreaterOrEqualsExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getInExpressionType() {
		return InExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getAddExpressionType() {
		return AddExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getSubExpressionType() {
		return SubExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getOrExpressionType() {
		return OrExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getMulExpressionType() {
		return MulExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getDivExpressionType() {
		return DivExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getIntegralDivExpressionType() {
		return IntegralDivExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getModuloExpressionType() {
		return ModuloExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getAndExpressionType() {
		return AndExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getNegateExpressionType() {
		return NegateExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getNotExpressionType() {
		return NotExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getFormatExpressionType() {
		return FormatExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getIdentifierExpressionType() {
		return IdentifierExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getStringExpressionType() {
		return StringExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getNumberExpressionType() {
		return NumberExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getIntegerExpressionType() {
		return IntegerExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getNilExpressionType() {
		return NilExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getFuncallExpressionType() {
		return FuncallExpressionType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getIdentifierType() {
		return IdentifierType;
	}
	public org.xteam.parser.runtime.reflect.AstNodeType getIntegerValueType() {
		return IntegerValueType;
	}
	
}
